Unit jpg_rw;

{ This file illustrates how to use the IJG code as a subroutine library
  to read or write JPEG image files.  You should look at this code in
  conjunction with the documentation file libjpeg.doc.

  This code will not do anything useful as-is, but it may be helpful as a
  skeleton for constructing routines that call the JPEG library. }

{ Original: example.c }

Interface
uses pictures;


{ Sample routine for JPEG compression.  We assume that the target file name
  and a compression quality factor are passed in. }

{GLOBAL}
Function SavePictureJPG(var p:picture;AlineProc:PAbstractLineProc):boolean;

{ Sample routine for JPEG decompression.  We assume that the source file name
  is passed in.  We want to return TRUE on success, FALSE on error. }

{GLOBAL}
Function LoadPictureJPG(var p:picture;AlineProc:PAbstractLineProc):integer;

implementation
uses formater,
{ Include file for users of JPEG library.
  You will need to have included system headers that define at least
  the typedefs FILE and size_t before you can include jpeglib.h.
  (stdio.h is sufficient on ANSI-conforming systems.)
  You may also wish to include "jerror.h". }
  jmorecfg, jerror, jpeglib,
  jdatadst, jcparam, jcapimin, jcapistd, jdapimin, jdatasrc, jdapistd;

var current_line : int;
const quality:int = 75;

{$IFOPT I+} {$DEFINE IoCheck} {$ENDIF}

{ <setjmp.h> is used for the optional error recovery mechanism shown in
  the second part of the example. }


{******************* JPEG COMPRESSION SAMPLE INTERFACE ******************}

{ This half of the example shows how to feed data into the JPEG compressor.
  We present a minimal version that does not worry about refinements such
  as error recovery (the JPEG code will just exit() if it gets an error). }


{ IMAGE DATA FORMATS:

  The standard input image format is a rectangular array of pixels, with
  each pixel having the same number of "component" values (color channels).
  Each pixel row is an array of JSAMPLEs (which typically are unsigned chars).
  If you are working with color data, then the color values for each pixel
  must be adjacent in the row; for example, R,G,B,R,G,B,R,G,B,... for 24-bit
  RGB color.

  For this example, we'll assume that this data structure matches the way
  our application has stored the image in memory, so we can just pass a
  pointer to our image buffer.  In particular, let's say that the image is
  RGB color and is described by: }


{ Sample routine for JPEG compression.  We assume that the target file name
  and a compression quality factor are passed in. }

{GLOBAL}
Function SavePictureJPG(var p:picture;AlineProc:PAbstractLineProc):boolean;
{procedure write_JPEG_file (filename : string;  quality : int);}
var
  { This struct contains the JPEG compression parameters and pointers to
    working space (which is allocated as needed by the JPEG library).
    It is possible to have several such structures, representing multiple
    compression/decompression processes, in existence at once.  We refer
    to any one struct (and its associated working data) as a "JPEG object". }
  cinfo : jpeg_compress_struct;
  { This struct represents a JPEG error handler.  It is declared separately
    because applications often want to supply a specialized error handler
    (see the second half of this file for an example).  But here we just
    take the easy way out and use the standard error handler, which will
    print a message on stderr and call exit() if compression fails.
    Note that this struct must live as long as the main JPEG parameter
    struct, to avoid dangling-pointer problems. }

  jerr : jpeg_error_mgr;
  { More stuff }
  outfile : FILE;		{ target file }
  row_pointer : array[0..0] of JSAMPROW ;	{ pointer to JSAMPLE row[s] }
  row_stride : int;		{ physical row width in image buffer }
  image_buffer : JSAMPROW;	{ Points to large array of R,G,B-order data }

  ukRadekX:^byte;
  ConvStruct:BasicFormStruct;

begin
  ukRadekX:=nil;
  SavePictureJPG:=true;
  { Step 1: allocate and initialize JPEG compression object }

  { We have to set up the error handler first, in case the initialization
    step fails.  (Unlikely, but it could happen if you are out of memory.)
    This routine fills in the contents of struct jerr, and returns jerr's
    address which we place into the link field in cinfo. }

  cinfo.err := jpeg_std_error(jerr);
  { msg_level that will be displayed. (Nomssi) }
  jerr.trace_level := 3;
  { Now we can initialize the JPEG compression object. }
  jpeg_create_compress(@cinfo);

  { Step 2: specify data destination (eg, a file) }
  { Note: steps 2 and 3 can be done in either order. }

  { Here we use the library-supplied code to send compressed data to a
    stdio stream.  You can also write your own code to do something else.
    VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
    requires it in order to write binary files. }

  Assign(outfile, p.filename^);
  {$I-}
  ReWrite(outfile, 1);
  {$IFDEF IoCheck} {$I+} {$ENDIF}
  if (IOresult <> 0) then
  begin
    WriteLn(output, 'can''t open ', p.filename^);
    Halt(1);
  end;
  jpeg_stdio_dest(@cinfo, @outfile);

  { Step 3: set parameters for compression }

  { First we supply a description of the input image.
    Four fields of the cinfo struct must be filled in: }

  cinfo.image_width := p.x;   		{ image width and height, in pixels }
  cinfo.image_height := p.y; 		{image_height;}
  cinfo.input_components := 3;		{ # of color components per pixel }
  cinfo.in_color_space := JCS_RGB; 	{ colorspace of input image }
  { Now use the library's routine to set default compression parameters.
    (You must set at least cinfo.in_color_space before calling this,
    since the defaults depend on the source color space.) }

  jpeg_set_defaults(@cinfo);
  { Now you can set any non-default parameters you wish to.
    Here we just illustrate the use of quality (quantization table) scaling: }

  jpeg_set_quality(@cinfo, quality, TRUE { limit to baseline-JPEG values });

  { Step 4: Start compressor }

  { TRUE ensures that we will write a complete interchange-JPEG file.
    Pass TRUE unless you are very sure of what you're doing. }

  jpeg_start_compress(@cinfo, TRUE);

  { Step 5: while (scan lines remain to be written) }
  {           jpeg_write_scanlines(...); }

  { Here we use the library's state variable cinfo.next_scanline as the
    loop counter, so that we don't have to keep track ourselves.
    To keep things simple, we pass one scanline per call; you can pass
    more if you wish, though. }

  row_stride := cinfo.image_width * 3;	{ JSAMPLEs per row in image_buffer }

  if((p.typ<>'C') or (p.planes<>24)) then
    begin
    ConvStruct.Items:=p.x;
    ConvStruct.SrcTyp:=p.Typ;
    if p.palette<>nil then ConvStruct.Palette:=addr(p.palette^.pal);
    if (p.Typ='P')and(p.palette=nil) then ConvStruct.SrcTyp:='G';
    ConvStruct.SrcPlanes:=p.planes;
    ConvStruct.DestTyp:='C';
    ConvStruct.DestPlanes:=24;
    ConvStruct.Options:=NoScale;

    Getmem(ukRadekX,3*p.x);
    end;

  if AlineProc<>nil then
		AlineProc^.InitPassing(p.y,'Saving JPG');

  while (cinfo.next_scanline < cinfo.image_height) do
    begin
    { jpeg_write_scanlines expects an array of pointers to scanlines.
      Here the array is only one element long, but you could pass
      more than one scanline at a time if that's more convenient. }

    if(ukRadekX=nil) then
       begin
       if cinfo.next_scanline < p.y then
		row_pointer[0] := addr(p.data^[cinfo.next_scanline]^);
       end
    else
       begin
       if cinfo.next_scanline < p.y then
		C_XX_YY(@ConvStruct,p.data^[cinfo.next_scanline],UkRadekX);
       row_pointer[0] := pointer(ukRadekX);
       end;
    {JSAMPROW(@image_buffer^[cinfo.next_scanline * row_stride]);}
    jpeg_write_scanlines(@cinfo, JSAMPARRAY(@row_pointer), 1);

    if AlineProc<>nil then AlineProc^.NextLine;
    end;

  if ukRadekX<>nil then begin;Getmem(ukRadekX,3*p.x);ukRadekX:=nil;end;

  { Step 6: Finish compression }

  jpeg_finish_compress(@cinfo);
  { After finish_compress, we can close the output file. }
  system.close(outfile);

  { Step 7: release JPEG compression object }

  { This is an important step since it will release a good deal of memory. }
  jpeg_destroy_compress(@cinfo);

  { And we're done! }
end;


{ SOME FINE POINTS:

  In the above loop, we ignored the return value of jpeg_write_scanlines,
  which is the number of scanlines actually written.  We could get away
  with this because we were only relying on the value of cinfo.next_scanline,
  which will be incremented correctly.  If you maintain additional loop
  variables then you should be careful to increment them properly.
  Actually, for output to a stdio stream you needn't worry, because
  then jpeg_write_scanlines will write all the lines passed (or else exit
  with a fatal error).  Partial writes can only occur if you use a data
  destination module that can demand suspension of the compressor.
  (If you don't know what that's for, you don't need it.)

  If the compressor requires full-image buffers (for entropy-coding
  optimization or a multi-scan JPEG file), it will create temporary
  files for anything that doesn't fit within the maximum-memory setting.
  (Note that temp files are NOT needed if you use the default parameters.)
  On some systems you may need to set up a signal handler to ensure that
  temporary files are deleted if the program is interrupted.  See libjpeg.doc.

  Scanlines MUST be supplied in top-to-bottom order if you want your JPEG
  files to be compatible with everyone else's.  If you cannot readily read
  your data in that order, you'll need an intermediate array to hold the
  image.  See rdtarga.c or rdbmp.c for examples of handling bottom-to-top
  source data using the JPEG code's internal virtual-array mechanisms. }




{******************* JPEG DECOMPRESSION SAMPLE INTERFACE ******************}

{ This half of the example shows how to read data from the JPEG decompressor.
  It's a bit more refined than the above, in that we show:
    (a) how to modify the JPEG library's standard error-reporting behavior;
    (b) how to allocate workspace using the library's memory manager.

  Just to make this example a little different from the first one, we'll
  assume that we do not intend to put the whole image into an in-memory
  buffer, but to send it line-by-line someplace else.  We need a one-
  scanline-high JSAMPLE array as a work buffer, and we will let the JPEG
  memory manager allocate it for us.  This approach is actually quite useful
  because we don't need to remember to deallocate the buffer separately: it
  will go away automatically when the JPEG object is cleaned up. }


{ ERROR HANDLING:

  The JPEG library's standard error handler (jerror.c) is divided into
  several "methods" which you can override individually.  This lets you
  adjust the behavior without duplicating a lot of code, which you might
  have to update with each future release.

  Our example here shows how to override the "error_exit" method so that
  control is returned to the library's caller when a fatal error occurs,
  rather than calling exit() as the standard error_exit method does.

  We use C's setjmp/longjmp facility to return control.  This means that the
  routine which calls the JPEG library must first execute a setjmp() call to
  establish the return point.  We want the replacement error_exit to do a
  longjmp().  But we need to make the setjmp buffer accessible to the
  error_exit routine.  To do this, we make a private extension of the
  standard JPEG error handler object.  (If we were using C++, we'd say we
  were making a subclass of the regular error handler.) }

{-$IFDEF TEST ---------------------------------------------------------------}

{extern}
type
  jmp_buf = pointer;

{ This routine does the output }
{  procedure put_scanline_someplace(buffer : JSAMPROW; row_stride : int);
     forward;}

  { define an error recovery point. Return 0 when OK }
  function setjmp(setjmp_buffer : jmp_buf) : int;
     forward;

  { Return control to the setjmp point }
  procedure longjmp(setjmp_buffer : jmp_buf; flag : int);
     forward;

{-$ENDIF --------------------------------------------------------------------}


{ Here's the extended error handler struct: }
type
  my_error_ptr = ^my_error_mgr;
  my_error_mgr = record
    pub : jpeg_error_mgr;	{ "public" fields }

    setjmp_buffer : jmp_buf;	{ for return to caller }
  end;


{ Here's the routine that will replace the standard error_exit method: }

{METHODDEF}
procedure my_error_exit (cinfo : j_common_ptr); far;
var
  myerr : my_error_ptr;
begin
  { cinfo^.err really points to a my_error_mgr struct, so coerce pointer }
  myerr := my_error_ptr (cinfo^.err);

  { Always display the message. }
  { We could postpone this until after returning, if we chose. }
  cinfo^.err^.output_message (cinfo);

  { Return control to the setjmp point }
  longjmp(myerr^.setjmp_buffer, 1);
end;


{ Sample routine for JPEG decompression.  We assume that the source file name
  is passed in.  We want to return 1 on success, 0 on error. }


{GLOBAL}
Function LoadPictureJPG(var p:picture;AlineProc:PAbstractLineProc):integer;
var
  { This struct contains the JPEG decompression parameters and pointers to
    working space (which is allocated as needed by the JPEG library). }

  cinfo : jpeg_decompress_struct;
  { We use our private extension JPEG error handler.
    Note that this struct must live as long as the main JPEG parameter
    struct, to avoid dangling-pointer problems. }

  jerr  : my_error_mgr;
  { More stuff }
  infile : FILE;		{ source file }
  buffer : JSAMPARRAY;		{ Output row buffer }
  row_stride : int;		{ physical row width in output buffer }

  line_size : int;


label Finish;
begin

  { In this example we want to open the input file before doing anything else,
    so that the setjmp() error recovery below can assume the file is open.
    VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
    requires it in order to read binary files. }
  LoadPictureJPG:=0;
  p.Erase;
  assign(infile,p.filename^);
  {$I-}
  line_size:=filemode;filemode:=0;
  Reset(infile, 1);
  filemode:=line_size;
  {$IFDEF IoCheck} {$I+} {$ENDIF}
  LoadPictureJPG:=InOutRes;
  if (IOresult <> 0) then
  begin
    WriteLn(output, 'can''t open ', p.filename^);
    exit;
  end;

{ Step 1: allocate and initialize JPEG decompression object }
  { We set up the normal JPEG error routines, then override error_exit. }
  cinfo.err := jpeg_std_error(jerr.pub);
  jerr.pub.error_exit := my_error_exit;
  jerr.pub.trace_level := 3;	{ I'm debbuging a lot (Nomssi) }
  { Establish the setjmp return context for my_error_exit to use. }
  if (setjmp(jerr.setjmp_buffer)<>0) then
  begin
    { If we get here, the JPEG code has signaled an error.
      We need to clean up the JPEG object, close the input file, and return. }
    { Nomssi: if we get here, we are in trouble, because e.g. cinfo.mem
	      is not guaranted to be NIL }
    jpeg_destroy_decompress(@cinfo);
    system.close(infile);
    LoadPictureJPG:=ErrAnother;
    exit;
  end;

  { Now we can initialize the JPEG decompression object. }
  jpeg_create_decompress(@cinfo);


{ Step 2: specify data source (eg, a file) }
  jpeg_stdio_src(@cinfo, @infile);


{ Step 3: read file parameters with jpeg_read_header() }
  jpeg_read_header(@cinfo, TRUE);
  { We can ignore the return value from jpeg_read_header since
      (a) suspension is not possible with the stdio data source, and
      (b) we passed TRUE to reject a tables-only JPEG file as an error.
    See libjpeg.doc for more info. }

  p.Create(cinfo.image_width,cinfo.image_height,24);
  if not(p.valid) then goto Finish;
  p.typ:='C';
  if AlineProc<>nil then
		AlineProc^.InitPassing(p.y,'Loading JPG');

  { Step 4: set parameters for decompression }

  { the defaults are set by jpeg_read_header(),
    we could choose to do nothing here. }

{  cinfo.scale_num := 1;
  cinfo.scale_denom := 1;	{ 1:1 scaling }
{  cinfo.dct_method := JDCT_IFAST;
  cinfo.quantize_colors := TRUE;
  cinfo.two_pass_quantize := TRUE;}
{  cinfo.dither_mode := JDITHER_FS;  { Floyd-Steinberg error diffusion dither }


  { Step 5: Start decompressor }

  jpeg_start_decompress(@cinfo);
  { We can ignore the return value since suspension is not possible
    with the stdio data source. }

  { We may need to do some setup of our own at this point before reading
    the data.  After jpeg_start_decompress() we have the correct scaled
    output image dimensions available, as well as the output colormap
    if we asked for color quantization.
    In this example, we need to make an output work buffer of the right size. }

  { JSAMPLEs per row in output buffer }
  row_stride := cinfo.output_width * cinfo.output_components;
  { Make a one-row-high sample array that will go away when done with image }
  buffer := cinfo.mem^.alloc_sarray
		(j_common_ptr(@cinfo), JPOOL_IMAGE, row_stride, 1);

  { Step 6: while (scan lines remain to be read) }
  {           jpeg_read_scanlines(...); }

  { Here we use the library's state variable cinfo.output_scanline as the
    loop counter, so that we don't have to keep track ourselves. }

  while (cinfo.output_scanline < cinfo.output_height) do
    begin
    { jpeg_read_scanlines expects an array of pointers to scanlines.
      Here the array is only one element long, but you could ask for
      more than one scanline at a time if that's more convenient. }

    jpeg_read_scanlines(@cinfo, buffer, 1);
    { Assume put_scanline_someplace wants a pointer and sample count. }

{   WriteLn(output, current_line:3, '. line of image data read');}

    line_size := 3 * cinfo.output_width;

{     BlockWrite(outfile, buffer^, row_stride);}
    if line_size > row_stride then
		line_size := row_stride;

    if current_line < p.y then
		Move(buffer^[0]^, p.data^[current_line]^, line_size);
    Inc(current_line);
    if AlineProc<>nil then AlineProc^.NextLine;
  end;

  { Nomssi }
{  save_color_map(@cinfo);{}


{ Step 7: Finish decompression }
  LoadPictureJPG:=0;
Finish:
  jpeg_finish_decompress(@cinfo);
  { We can ignore the return value since suspension is not possible
    with the stdio data source. }

{ Step 8: Release JPEG decompression object }

  { This is an important step since it will release a good deal of memory. }
  jpeg_destroy_decompress(@cinfo);

  { After finish_decompress, we can close the input file.
    Here we postpone it until after no more JPEG errors are possible,
    so as to simplify the setjmp error logic above.  (Actually, I don't
    think that jpeg_destroy can do an error exit, but why assume anything...) }
  system.close(infile);

  { At this point you may want to check to see whether any corrupt-data
    warnings occurred (test whether jerr.pub.num_warnings is nonzero). }

  { And we're done! }
end;


{ SOME FINE POINTS:

  In the above code, we ignored the return value of jpeg_read_scanlines,
  which is the number of scanlines actually read.  We could get away with
  this because we asked for only one line at a time and we weren't using
  a suspending data source.  See libjpeg.doc for more info.

  We cheated a bit by calling alloc_sarray() after jpeg_start_decompress();
  we should have done it beforehand to ensure that the space would be
  counted against the JPEG max_memory setting.  In some systems the above
  code would risk an out-of-memory error.  However, in general we don't
  know the output image dimensions before jpeg_start_decompress(), unless we
  call jpeg_calc_output_dimensions().  See libjpeg.doc for more about this.

  Scanlines are returned in the same order as they appear in the JPEG file,
  which is standardly top-to-bottom.  If you must emit data bottom-to-top,
  you can use one of the virtual arrays provided by the JPEG memory manager
  to invert the data.  See wrbmp.c for an example.

  As with compression, some operating modes may require temporary files.
  On some systems you may need to set up a signal handler to ensure that
  temporary files are deleted if the program is interrupted.  See libjpeg.doc. }

{ Return control to the setjmp point }
procedure longjmp(setjmp_buffer : jmp_buf; flag : int);
begin
  Halt(2);
end;

{ define an error recovery point. Return 0 when OK }
function setjmp(setjmp_buffer : jmp_buf) : int;
begin
  setjmp := 0;
  current_line := 0;
end;


end.